// 购物网站工具函数

import type { Product, CartItem, Order, User } from '@/types/mall'
import { 
  ORDER_STATUS_MAP, 
  ORDER_STATUS_COLOR_MAP, 
  PRODUCT_STATUS_MAP,
  USER_STATUS_MAP,
  COUPON_TYPE_MAP,
  GENDER_MAP,
  ERROR_CODE_MAP,
  REGEX
} from '@/constants/mall'

/**
 * 格式化价格显示
 * @param price 价格（分）
 * @param showSymbol 是否显示货币符号
 * @returns 格式化后的价格字符串
 */
export function formatPrice(price: number, showSymbol = true): string {
  const yuan = (price / 100).toFixed(2)
  return showSymbol ? `¥${yuan}` : yuan
}

/**
 * 格式化数字显示（千分位）
 * @param num 数字
 * @returns 格式化后的数字字符串
 */
export function formatNumber(num: number): string {
  return num.toLocaleString()
}

/**
 * 获取订单状态文本
 * @param status 订单状态
 * @returns 状态文本
 */
export function getOrderStatusText(status: keyof typeof ORDER_STATUS_MAP): string {
  return ORDER_STATUS_MAP[status] || '未知状态'
}

/**
 * 获取订单状态颜色
 * @param status 订单状态
 * @returns 状态颜色
 */
export function getOrderStatusColor(status: keyof typeof ORDER_STATUS_COLOR_MAP): string {
  return ORDER_STATUS_COLOR_MAP[status] || '#999999'
}

/**
 * 获取商品状态文本
 * @param status 商品状态
 * @returns 状态文本
 */
export function getProductStatusText(status: keyof typeof PRODUCT_STATUS_MAP): string {
  return PRODUCT_STATUS_MAP[status] || '未知状态'
}

/**
 * 获取用户状态文本
 * @param status 用户状态
 * @returns 状态文本
 */
export function getUserStatusText(status: keyof typeof USER_STATUS_MAP): string {
  return USER_STATUS_MAP[status] || '未知状态'
}

/**
 * 获取优惠券类型文本
 * @param type 优惠券类型
 * @returns 类型文本
 */
export function getCouponTypeText(type: keyof typeof COUPON_TYPE_MAP): string {
  return COUPON_TYPE_MAP[type] || '未知类型'
}

/**
 * 获取性别文本
 * @param gender 性别
 * @returns 性别文本
 */
export function getGenderText(gender: keyof typeof GENDER_MAP): string {
  return GENDER_MAP[gender] || '未知'
}

/**
 * 计算商品折扣
 * @param originalPrice 原价
 * @param currentPrice 现价
 * @returns 折扣信息
 */
export function calculateDiscount(originalPrice: number, currentPrice: number) {
  if (originalPrice <= currentPrice) {
    return { discount: 0, discountText: '' }
  }
  
  const discount = Math.round((1 - currentPrice / originalPrice) * 10) / 10
  const discountText = `${(discount * 10).toFixed(1)}折`
  
  return { discount, discountText }
}

/**
 * 计算购物车总价
 * @param items 购物车商品项
 * @param selectedOnly 是否只计算选中的商品
 * @returns 总价信息
 */
export function calculateCartTotal(items: CartItem[], selectedOnly = false) {
  const filteredItems = selectedOnly ? items.filter(item => item.selected) : items
  
  const totalQuantity = filteredItems.reduce((sum, item) => sum + item.quantity, 0)
  const totalPrice = filteredItems.reduce((sum, item) => {
    const price = item.sku?.price || item.product.defaultPrice
    return sum + price * item.quantity
  }, 0)
  
  return { totalQuantity, totalPrice }
}

/**
 * 验证手机号格式
 * @param phone 手机号
 * @returns 是否有效
 */
export function validatePhone(phone: string): boolean {
  return REGEX.PHONE.test(phone)
}

/**
 * 验证邮箱格式
 * @param email 邮箱
 * @returns 是否有效
 */
export function validateEmail(email: string): boolean {
  return REGEX.EMAIL.test(email)
}

/**
 * 验证密码格式
 * @param password 密码
 * @returns 是否有效
 */
export function validatePassword(password: string): boolean {
  return REGEX.PASSWORD.test(password)
}

/**
 * 验证身份证号格式
 * @param idCard 身份证号
 * @returns 是否有效
 */
export function validateIdCard(idCard: string): boolean {
  return REGEX.ID_CARD.test(idCard)
}

/**
 * 验证邮政编码格式
 * @param postalCode 邮政编码
 * @returns 是否有效
 */
export function validatePostalCode(postalCode: string): boolean {
  return REGEX.POSTAL_CODE.test(postalCode)
}

/**
 * 生成唯一ID
 * @param prefix 前缀
 * @returns 唯一ID
 */
export function generateId(prefix = ''): string {
  const timestamp = Date.now().toString(36)
  const random = Math.random().toString(36).substr(2, 9)
  return `${prefix}${timestamp}${random}`
}

/**
 * 获取错误信息
 * @param code 错误代码
 * @returns 错误信息
 */
export function getErrorMessage(code: number): string {
  return ERROR_CODE_MAP[code] || '未知错误'
}

/**
 * 格式化时间显示
 * @param time 时间字符串或时间戳
 * @param format 格式
 * @returns 格式化后的时间字符串
 */
export function formatTime(time: string | number, format = 'YYYY-MM-DD HH:mm:ss'): string {
  // 这里可以使用 dayjs 或其他时间库
  const date = new Date(time)
  
  if (format === 'YYYY-MM-DD') {
    return date.toLocaleDateString('zh-CN')
  }
  
  if (format === 'YYYY-MM-DD HH:mm:ss') {
    return date.toLocaleString('zh-CN')
  }
  
  return date.toLocaleString('zh-CN')
}

/**
 * 获取相对时间
 * @param time 时间字符串或时间戳
 * @returns 相对时间字符串
 */
export function getRelativeTime(time: string | number): string {
  const now = Date.now()
  const target = new Date(time).getTime()
  const diff = now - target
  
  const minute = 60 * 1000
  const hour = 60 * minute
  const day = 24 * hour
  const month = 30 * day
  const year = 365 * day
  
  if (diff < minute) {
    return '刚刚'
  } else if (diff < hour) {
    return `${Math.floor(diff / minute)}分钟前`
  } else if (diff < day) {
    return `${Math.floor(diff / hour)}小时前`
  } else if (diff < month) {
    return `${Math.floor(diff / day)}天前`
  } else if (diff < year) {
    return `${Math.floor(diff / month)}个月前`
  } else {
    return `${Math.floor(diff / year)}年前`
  }
}

/**
 * 深拷贝对象
 * @param obj 要拷贝的对象
 * @returns 拷贝后的对象
 */
export function deepClone<T>(obj: T): T {
  if (obj === null || typeof obj !== 'object') {
    return obj
  }
  
  if (obj instanceof Date) {
    return new Date(obj.getTime()) as unknown as T
  }
  
  if (obj instanceof Array) {
    return obj.map(item => deepClone(item)) as unknown as T
  }
  
  if (typeof obj === 'object') {
    const cloned = {} as T
    Object.keys(obj).forEach(key => {
      cloned[key as keyof T] = deepClone(obj[key as keyof T])
    })
    return cloned
  }
  
  return obj
}

/**
 * 防抖函数
 * @param func 要执行的函数
 * @param delay 延迟时间
 * @returns 防抖后的函数
 */
export function debounce<T extends (...args: any[]) => any>(
  func: T,
  delay: number
): (...args: Parameters<T>) => void {
  let timeoutId: NodeJS.Timeout
  
  return (...args: Parameters<T>) => {
    clearTimeout(timeoutId)
    timeoutId = setTimeout(() => func(...args), delay)
  }
}

/**
 * 节流函数
 * @param func 要执行的函数
 * @param delay 延迟时间
 * @returns 节流后的函数
 */
export function throttle<T extends (...args: any[]) => any>(
  func: T,
  delay: number
): (...args: Parameters<T>) => void {
  let lastExecTime = 0
  
  return (...args: Parameters<T>) => {
    const now = Date.now()
    if (now - lastExecTime >= delay) {
      func(...args)
      lastExecTime = now
    }
  }
}

/**
 * 格式化文件大小
 * @param size 文件大小（字节）
 * @returns 格式化后的文件大小
 */
export function formatFileSize(size: number): string {
  const units = ['B', 'KB', 'MB', 'GB', 'TB']
  let index = 0
  
  while (size >= 1024 && index < units.length - 1) {
    size /= 1024
    index++
  }
  
  return `${size.toFixed(2)} ${units[index]}`
}

/**
 * 生成随机颜色
 * @returns 随机颜色值
 */
export function generateRandomColor(): string {
  return `#${Math.floor(Math.random() * 16777215).toString(16)}`
}

/**
 * 检查是否为空值
 * @param value 要检查的值
 * @returns 是否为空
 */
export function isEmpty(value: any): boolean {
  if (value === null || value === undefined) {
    return true
  }
  
  if (typeof value === 'string') {
    return value.trim() === ''
  }
  
  if (Array.isArray(value)) {
    return value.length === 0
  }
  
  if (typeof value === 'object') {
    return Object.keys(value).length === 0
  }
  
  return false
}